═══ 1. Disclaimer ═══

This on-line document was generated automatically from its printed version 
LaTeX source. Some places in the document (especially tables) may look ugly due 
to the conversion program limits. These problems are being worked on and are 
supposed to be solved in the final release. 


═══ 2. Title Page ═══

 xTech Development System 

 ISO Modula-2 Language Reference 

 xTech Ltd, 1996 

XDS software and documentation copyright (c) 1991-1996 xTech Ltd. (xTech). 

Information in this document is subject to change without notice and does not 
represent a commitment on the part of xTech. 

All rights reserved. You may use the enclosed software on a single computer; 
transfer the software from one computer to another, provided that the software 
is used on only one computer at a time and that you remove any copies of the 
software on the computer from which the copies were made; make copies of the 
software for backup purposes only. 

XDS software and documentation have been tested and reviewed. Nevertheless, 
xTech makes no warranty or representation, either express or implied, with 
respect to the software and documentation included with XDS. In no event will 
xTech be liable for direct, indirect, special, incidental or consequential 
damages resulting from any defect in the software or documentation included 
with this product. In particular, xTech shall have no liability for any 
programs or data used with this product, including the cost of recovering 
programs or data. 

XDS is a trademark of xTech Ltd. 

All trademarks and copyrights mentioned in this documentation are the property 
of their respective holders. 


═══ 3. Introduction ═══

This document contains lexis and syntax definitions only. The full ISO Modula-2 
Reference will be provided after we receive a copy of the recently published 
ISO Modula-2 Standard. 


═══ 4. The Lexis ═══

The Modula-2 Lexis is the specification of the lexical elements of Modula-2 
source code including white space, comments, source code directives, and the 
tokens that are used in the concrete syntax. All the symbols and pervasive 
identifiers of Modula-2 are defined in this section. 

     Source Code Structure 
     Word tokens 
     Symbols and Operators 
     Constant Literals 
     Separators 
     Letters and National Characters 


═══ 4.1. Source Code Structure ═══

modula2 source code= { delimited token }, { separator } ; 

delimited token= { separator }, token ; 

token= word token | symbol | constant literal ; 

NOTE: A token is the largest sequence of characters that satisfies the 
definitions. Consequently, a word token must be separated from a following word 
token, numeric literal, string literal or character number literal. 
Furthermore, a numeric literal must be separated from a following numeric 
literal or character number literal. 


═══ 4.2. Word tokens ═══

word token= identifier | keyword ; 

     Identifiers 
     Portable Identifiers 
     Full Identifiers 
     Pervasive Identifiers 
     Keywords 


═══ 4.2.1. Identifiers ═══

identifier= portable identifier | full identifier | pervasive identifier ; 


═══ 4.2.2. Portable Identifiers ═══

portable identifier= 
( simple letter | low line ), { simple alphanumeric | low line } ; 

low line= "_" ; 


═══ 4.2.3. Full Identifiers ═══

full identifier= 
( national letter | low line ), { national alphanumeric | low line } ; 


═══ 4.2.4. Pervasive Identifiers ═══

pervasive identifier= 
"ABS" | "BITSET" | "BOOLEAN" | "CARDINAL" | 
"CAP" | "CHR" | "CHAR" | "COMPLEX" | 
"CMPLX" | "DEC" | "DISPOSE" | "EXCL" | 
"FALSE" | "FLOAT" | "HALT" | "HIGH" | 
"IM" | "INC" | "INCL" | "INT" | 
"INTERRUPTIBLE" | "INTEGER" | "LENGTH" | "LFLOAT" | 
"LONGCOMPLEX" | "LONGREAL" | "MAX" | "MIN" | 
"NEW" | "NIL" | "ODD" | "ORD" | 
"PROC" | "PROTECTION" | "RE" | "REAL" | 
"SIZE" | "TRUE" | "TRUNC" | "UNINTERRUPTIBLE" | 
"VAL" ; 

NOTE: Pervasive identifiers are not reserved words; if redeclared in a program, 
they will no longer have their predefined meaning in the scope of the 
redeclared identifier. 


═══ 4.2.5. Keywords ═══

keyword= 
"AND" | "ARRAY" | "BEGIN" | "BY" | 
"CASE" | "CONST" | "DEFINITION" | "DIV" | 
"DO" | "ELSE" | "ELSIF" | "END" | 
"EXIT" | "EXCEPT" | "EXPORT" | "FINALLY" | 
"FOR" | "FORWARD" | "FROM" | "IF" | 
"IMPLEMENTATION" | "IMPORT" | "IN" | "LOOP" | 
"MOD" | "MODULE" | "NOT" | "OF" | 
"OR" | "PACKEDSET" | "POINTER" | "PROCEDURE" | 
"QUALIFIED" | "RECORD" | "REM" | "RETRY" | 
"REPEAT" | "RETURN" | "SET" | "THEN" | 
"TO" | "TYPE" | "UNTIL" | "VAR" | 
"WHILE" | "WITH" ; 

NOTE: The keywords AND, DIV, IN, MOD, NOT, OR and REM are operator keywords; 
the rest are punctuation keywords. 


═══ 4.3. Symbols and Operators ═══

symbol= required symbol | symbol with alternatives | operator ; 

     Required Symbols 
     Symbols with alternatives 
     Operators 


═══ 4.3.1. Required Symbols ═══

required symbol= 
colon | comma | ellipsis | equals | 
period | semicolon | left parenthesis | right parenthesis ; 

colon= ":" ; 

comma= "," ; 

ellipsis= ".." ; 

equals= "=" ; 

period= "." ; 

semicolon= ";" ; 

left parenthesis= "(" ; 

right parenthesis= ")" ; 


═══ 4.3.2. Symbols with alternatives ═══

symbol with alternatives= 
left bracket | right bracket | left brace | right brace | case separator ; 

left bracket= preferred left bracket | required left bracket ; 

preferred left bracket= "[" ; 

required left bracket= "(!" ; 

right bracket= preferred right bracket | required right bracket ; 

preferred right bracket= "]" ; 

required right bracket= "!)" ; 

left brace= preferred left brace | required left brace ; 

preferred left brace= "" ; 

required left brace= "(:" ; 

right brace= preferred right brace | required right brace ; 

preferred right brace= "" ; 

required right brace= ":)" ; 

case separator= preferred case separator | required case separator ; 

preferred case separator= "|" ; 

required case separator= "!" ; 


═══ 4.3.3. Operators ═══

operator= 
assignment operator | plus operator | set union operator | 
string catenate symbol | minus operator | set difference operator | 
logical disjunction operator | multiplication operator | division operator | 
div operator | mod operator | rem operator | 
set intersection operator | symmetric set difference operator | 
logical conjunction operator | sign | logical negation operator | equals 
operator | 
inequality operator | less than operator | greater than operator | 
less than or equal operator | greater than or equal operator | subset operator 
| 
superset operator | set membership operator | dereferencing operator ; 

assignment operator= ":=" ; 

plus operator= "+" ; 

set union operator= "+" ; 

string catenate symbol= "+" ; 

minus operator= "-" ; 

set difference operator= "-" ; 

logical disjunction operator= "OR" ; 

multiplication operator= "*" ; 

division operator= "/" ; 

div operator= "DIV" ; 

mod operator= "MOD" ; 

rem operator= "REM" ; 

set intersection operator= "*" ; 

symmetric set difference operator= "/" ; 

logical conjunction operator= and keyword | and synonym ; 

and keyword= "AND" ; 

and synonym= "&" ; 

sign= identity operator | arithmetic negation operator ; 

identity operator= "+" ; 

arithmetic negation operator= "-" ; 

logical negation operator= not keyword | not synonym ; 

not keyword= "NOT" ; 

not synonym= "" ; 

equals operator= "=" ; 

inequality operator= not equals operator | not equals synonym ; 

not equals operator= "<>" ; 

not equals synonym= "#" ; 

less than operator= "<" ; 

greater than operator= ">" ; 

less than or equal operator= "<=" ; 

greater than or equal operator= ">=" ; 

subset operator= "<=" ; 

superset operator= ">=" ; 

set membership operator= "IN" ; 

dereferencing operator= 
preferred dereferencing operator | required dereferencing operator ; 

preferred dereferencing operator= "^" ; 

required dereferencing operator= "@" ; 


═══ 4.4. Constant Literals ═══

     Whole Number Literals 
     Real Literals 
     String Literals 


═══ 4.4.1. Whole Number Literals ═══

whole number literal= decimal number | octal number | hexadecimal number ; 

decimal number= digit, { digit } ; 

digit= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ; 

octal number= octal digit, { octal digit }, "B" ; 

octal digit= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" ; 

hexadecimal number= digit, { hex digit }, "H" ; 

hex digit= 
"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | 
"8" | "9" | "A" | "B" | "C" | "D" | "E" | "F" ; 


═══ 4.4.2. Real Literals ═══

real literal= digit, { digit }, ".", { digit }, [ scale factor ] ; 

scale factor= "E", [ sign ], digit, { digit } ; 


═══ 4.4.3. String Literals ═══

string literal= quoted string | character number literal ; 

quoted string= 
single quote, { quotable character - single quote }, single quote | 
double quote, { quotable character - double quote }, double quote ; 

single quote= "'" ; 

double quote= '"' ; 

quotable character= national graphic character | space | white space control ; 

NOTES: 

     A quoted string cannot contain both single and double quote characters 
      (since one or the other will mark the end of the string). 

     A quoted string cannot cross a line boundary. 

 character number literal= octal digit, { octal digit }, "C" ; 


═══ 4.5. Separators ═══

separator= white space | comment | source code directive ; 

     White Space 
     Comments 
     Source Code Directives 


═══ 4.5.1. White Space ═══

white space= space | new line | white space control ; 

space= " " ; 

new line= ? possibly empty implementation-defined character sequence ? ; 

white space control= 
? implementation-defined character sequence that shall not include new line ? ; 


═══ 4.5.2. Comments ═══

comment= "(*", comment body, "*)" ; 

comment body= { national character | separator } ; 

NOTE: Since comments may be nested, the addition of comment delimiters around 
program text that has quoted strings containing comment delimiters may result 
in a different program from that which was intended (and probably in an 
incorrect one). 


═══ 4.5.3. Source Code Directives ═══

source code directive= "<*", directive body, "*>" ; 

directive body= comment body ; 


═══ 4.6. Letters and National Characters ═══

national character= national graphic character | format effector | space ; 

national graphic character= 
simple alphanumeric | national alphanumeric | 
implementation defined graphic | punctuation character ; 

simple alphanumeric= simple letter | digit ; 

simple letter= 
"A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | 
"J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | 
"S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | 
"a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | 
"j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | 
"s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" ; 

national alphanumeric= national letter | national numeric ; 

national letter= ? implementation-defined alphabetic character ? ; 

national numeric= ? implementation-defined numeric character ? ; 

implementation defined graphic= ? implementation-defined character ? ; 

punctuation character= 
? implementation-defined punctuation character ? - national alphanumeric ; 

format effector= ? implementation-defined format effector ? ; 


═══ 5. Collected Modula-2 Concrete Syntax ═══

     Programs, Program Modules, and Separate Modules 
     Definitions and Declarations 
     Data Types 
     Blocks 
     Statements 
     Variable Designators 
     Expressions 
     Parameter Compatibility and Argument Binding 


═══ 5.1. Programs, Program Modules, and Separate Modules ═══

     Programs and Compilation Modules 
     Program Modules 
     Definition Modules 
     Implementation Modules 
     Import Lists 
     Export Lists 
     Protected Modules 


═══ 5.1.1. Programs and Compilation Modules ═══

compilation module= 
program module | definition module | implementation module ; 


═══ 5.1.2. Program Modules ═══

program module= 
"MODULE", module identifier, [ interrupt protection ], ";", 
import lists, 
module block, module identifier, "." ; 

module identifier= identifier ; 


═══ 5.1.3. Definition Modules ═══

definition module= 
"DEFINITION", "MODULE", module identifier, ";", 
import lists, 
definitions, 
"END", module identifier, "." ; 


═══ 5.1.4. Implementation Modules ═══

     Sourced Implementation Modules 


═══ 5.1.4.1. Sourced Implementation Modules ═══

implementation module= 
"IMPLEMENTATION", "MODULE", module identifier, [ interrupt protection ], ";", 
import lists, 
module block, module identifier, "." ; 


═══ 5.1.5. Import Lists ═══

import lists= { import list } ; 

import list= simple import | unqualified import ; 

simple import= "IMPORT", identifier list, ";" ; 

unqualified import= "FROM", module identifier, "IMPORT", identifier list, ";" ; 


═══ 5.1.6. Export Lists ═══

export list= unqualified export | qualified export ; 

unqualified export= "EXPORT", identifier list, ";" ; 

qualified export= "EXPORT", "QUALIFIED", identifier list, ";" ; 


═══ 5.1.7. Protected Modules ═══

interrupt protection= "[", protection expression, "]" ; 

protection expression= constant expression ; 


═══ 5.2. Definitions and Declarations ═══

     Qualified Identifiers 
     Definitions 
     Type Definitions 
     Procedure Headings 
     Declarations 
     Constant Declarations 
     Type Declarations 
     Variable Declarations 
     Procedure Declarations 
     Local Module Declarations 


═══ 5.2.1. Qualified Identifiers ═══

qualified identifier= { qualifying identifier, "." }, identifier ; 

qualifying identifier= module identifier ; 


═══ 5.2.2. Definitions ═══

definitions= { definition } ; 

definition= 
"CONST", { constant declaration, ";" } | 
"TYPE", { type definition, ";" } | 
"VAR", { variable declaration, ";" } | 
procedure heading, ";" ; 


═══ 5.2.3. Type Definitions ═══

type definition= type declaration | opaque type definition ; 

opaque type definition= identifier ; 


═══ 5.2.4. Procedure Headings ═══

procedure heading= proper procedure heading | function procedure heading ; 

     Proper Procedure Headings 
     Function Procedure Headings 
     Formal Parameters 


═══ 5.2.4.1. Proper Procedure Headings ═══

proper procedure heading= 
"PROCEDURE", procedure identifier, [ formal parameters ] ; 

formal parameters= "(", [ formal parameter list ], ")" ; 

formal parameter list= formal parameter, { ";", formal parameter } ; 


═══ 5.2.4.2. Function Procedure Headings ═══

function procedure heading= 
"PROCEDURE", procedure identifier, formal parameters, ":", function result type 
; 

function result type= type identifier ; 


═══ 5.2.4.3. Formal Parameters ═══

formal parameter= 
value parameter specification | variable parameter specification ; 

value parameter specification= identifier list, ":", formal type ; 

variable parameter specification= "VAR", identifier list, ":", formal type ; 


═══ 5.2.5. Declarations ═══

declarations= { declaration } ; 

declaration= 
"CONST", { constant declaration, ";" } | 
"TYPE", { type declaration, ";" } | 
"VAR", { variable declaration, ";" } | 
procedure declaration, ";" | 
local module declaration, ";" ; 


═══ 5.2.6. Constant Declarations ═══

constant declaration= identifier, "=", constant expression ; 


═══ 5.2.7. Type Declarations ═══

type declaration= identifier, "=", type denoter ; 


═══ 5.2.8. Variable Declarations ═══

variable declaration= variable identifier list, ":", type denoter ; 

variable identifier list= 
identifier, [ machine address ], { ",", identifier, [ machine address ] } ; 

machine address= "[", value of address type, "]" ; 

value of address type= constant expression ; 


═══ 5.2.9. Procedure Declarations ═══

procedure declaration= 
proper procedure declaration | function procedure declaration ; 

proper procedure declaration= 
proper procedure heading, ";", 
( proper procedure block, procedure identifier | "FORWARD" ) ; 

procedure identifier= identifier ; 

function procedure declaration= 
function procedure heading, ";", 
( function procedure block, procedure identifier | "FORWARD" ) ; 


═══ 5.2.10. Local Module Declarations ═══

local module declaration= 
"MODULE", module identifier, [ interrupt protection ], ";", 
import lists, [ export list ], 
module block, module identifier ; 


═══ 5.3. Data Types ═══

     Type Denoters and Ordinal Type Denoters 
     Type Identifiers 
     New Types 
     Enumeration Types 
     Subrange Types 
     Set Types 
     Packedset Types 
     Pointer Types 
     Procedure Types 
     Array Types 
     Record Types 


═══ 5.3.1. Type Denoters and Ordinal Type Denoters ═══

type denoter= type identifier | new type ; 

ordinal type denoter= ordinal type identifier | new ordinal type ; 


═══ 5.3.2. Type Identifiers ═══

type identifier= qualified identifier ; 

ordinal type identifier= type identifier ; 


═══ 5.3.3. New Types ═══

new type= 
new ordinal type | set type | 
packedset type | pointer type | 
procedure type | array type | 
record type ; 

new ordinal type= enumeration type | subrange type ; 


═══ 5.3.4. Enumeration Types ═══

enumeration type= "(", identifier list, ")" ; 

identifier list= identifier, { ",", identifier } ; 


═══ 5.3.5. Subrange Types ═══

subrange type= 
[0 pt] [ range type ], "[", constant expression, "..", constant expression, "]" 
; 

range type= ordinal type identifier ; 


═══ 5.3.6. Set Types ═══

set type= "SET", "OF", base type ; 

base type= ordinal type denoter ; 


═══ 5.3.7. Packedset Types ═══

packedset type= "PACKEDSET", "OF", base type ; 


═══ 5.3.8. Pointer Types ═══

pointer type= "POINTER", "TO", bound type ; 

bound type= type denoter ; 


═══ 5.3.9. Procedure Types ═══

procedure type= proper procedure type | function procedure type ; 

proper procedure type= 
"PROCEDURE", [ "(", [ formal parameter type list ], ")" ] ; 

function procedure type= 
"PROCEDURE", "(", [ formal parameter type list ], ")", ":", function result 
type ; 

     Formal Parameter Type Lists 
     Formal Types 


═══ 5.3.9.1. Formal Parameter Type Lists ═══

formal parameter type list= 
formal parameter type, { ",", formal parameter type } ; 

formal parameter type= 
variable formal type | value formal type ; 

variable formal type= "VAR", formal type ; 

value formal type= formal type ; 


═══ 5.3.9.2. Formal Types ═══

formal type= type identifier | open array formal type ; 

open array formal type= "ARRAY", "OF", open array component type ; 

open array component type= formal type ; 


═══ 5.3.10. Array Types ═══

array type= "ARRAY", index type, { ",", index type }, "OF", component type ; 

index type= ordinal type denoter ; 

component type= type denoter ; 


═══ 5.3.11. Record Types ═══

record type= "RECORD", field list, "END" ; 

field list= fields, { ";", fields } ; 

fields= [ fixed fields | variant fields ] ; 

     Fixed Fields 
     Variant Fields 


═══ 5.3.11.1. Fixed Fields ═══

fixed fields= identifier list, ":", field type ; 

field type= type denoter ; 


═══ 5.3.11.2. Variant Fields ═══

variant fields= "CASE", tag field, "OF", variant list, "END" ; 

tag field= [ tag identifier ], ":", tag type ; 

tag identifier= identifier ; 

tag type= ordinal type identifier ; 

variant list= variant, { "|", variant }, [ variant else part ] ; 

variant else part= "ELSE", field list ; 

variant= [ variant label list, ":", field list ] ; 

variant label list= variant label, { ",", variant label } ; 

variant label= constant expression, [ "..", constant expression ] ; 


═══ 5.4. Blocks ═══

     Proper Procedure Blocks 
     Function Procedure Blocks 
     Module Blocks 
     Block Bodies and Exception Handling 


═══ 5.4.1. Proper Procedure Blocks ═══

proper procedure block= declarations, [ procedure body ], "END" ; 

procedure body= "BEGIN", block body ; 


═══ 5.4.2. Function Procedure Blocks ═══

function procedure block= declarations, function body, "END" ; 

function body= "BEGIN", block body ; 


═══ 5.4.3. Module Blocks ═══

module block= declarations, [ module body ], "END" ; 

module body= initialization body, [ finalization body ] ; 

initialization body= "BEGIN", block body ; 

finalization body= "FINALLY", block body ; 


═══ 5.4.4. Block Bodies and Exception Handling ═══

block body= normal part, [ "EXCEPT", exceptional part ] ; 

normal part= statement sequence ; 

exceptional part= statement sequence ; 


═══ 5.5. Statements ═══

statement= 
empty statement | assignment statement | procedure call | 
return statement | retry statement | with statement | 
if statement | case statement | while statement | 
repeat statement | loop statement | exit statement | 
for statement ; 

     Statement Sequences 
     Empty Statements 
     Assignment Statements 
     Procedure Calls 
     Return Statements 
     Retry Statements 
     With Statements 
     If Statements 
     Case Statements 
     While Statements 
     Repeat Statements 
     Loop Statements 
     Exit Statements 
     For Statements 


═══ 5.5.1. Statement Sequences ═══

statement sequence= statement, { ";", statement } ; 


═══ 5.5.2. Empty Statements ═══

empty statement= ; 


═══ 5.5.3. Assignment Statements ═══

assignment statement= variable designator, ":=", expression ; 


═══ 5.5.4. Procedure Calls ═══

procedure call= procedure designator, [ actual parameters ] ; 

procedure designator= value designator ; 


═══ 5.5.5. Return Statements ═══

return statement= simple return statement | function return statement ; 

simple return statement= "RETURN" ; 

function return statement= "RETURN", expression ; 


═══ 5.5.6. Retry Statements ═══

retry statement= "RETRY" ; 


═══ 5.5.7. With Statements ═══

with statement= "WITH", record designator, "DO", statement sequence, "END" ; 

record designator= variable designator | value designator ; 


═══ 5.5.8. If Statements ═══

if statement= guarded statements, [ if else part ], "END" ; 

guarded statements= 
"IF", boolean expression, "THEN", statement sequence, 
{ "ELSIF", boolean expression, "THEN", statement sequence } ; 

if else part= "ELSE", statement sequence ; 

boolean expression= expression ; 


═══ 5.5.9. Case Statements ═══

case statement= "CASE", case selector, "OF", case list, "END" ; 

case selector= ordinal expression ; 

case list= case alternative, { "|", case alternative }, [ case else part ] ; 

case else part= "ELSE", statement sequence ; 

     Case Alternatives 


═══ 5.5.9.1. Case Alternatives ═══

case alternative= [ case label list, ":", statement sequence ] ; 

case label list= case label, { ",", case label } ; 

case label= constant expression, [ "..", constant expression ] ; 


═══ 5.5.10. While Statements ═══

while statement= 
"WHILE", boolean expression, "DO", statement sequence, "END" ; 


═══ 5.5.11. Repeat Statements ═══

repeat statement= 
"REPEAT", statement sequence, "UNTIL", boolean expression ; 


═══ 5.5.12. Loop Statements ═══

loop statement= "LOOP", statement sequence, "END" ; 


═══ 5.5.13. Exit Statements ═══

exit statement= "EXIT" ; 


═══ 5.5.14. For Statements ═══

for statement= 
"FOR", control variable identifier, ":=", initial value, 
"TO", final value, [ "BY", step size ], "DO", 
statement sequence, "END" ; 

control variable identifier= identifier ; 

initial value= ordinal expression ; 

final value= ordinal expression ; 

step size= constant expression ; 


═══ 5.6. Variable Designators ═══

variable designator= 
entire designator | indexed designator | 
selected designator | dereferenced designator ; 

     Entire Designators 
     Indexed Designators 
     Selected Designators 
     Dereferenced Designators 


═══ 5.6.1. Entire Designators ═══

entire designator= qualified identifier ; 


═══ 5.6.2. Indexed Designators ═══

indexed designator= 
array variable designator, "[", index expression, { ",", index expression }, 
"]" ; 

array variable designator= variable designator ; 

index expression= ordinal expression ; 


═══ 5.6.3. Selected Designators ═══

selected designator= record variable designator, ".", field identifier ; 

record variable designator= variable designator ; 

field identifier= identifier ; 


═══ 5.6.4. Dereferenced Designators ═══

dereferenced designator= pointer variable designator, " " ; 

pointer variable designator= variable designator ; 


═══ 5.7. Expressions ═══

expression= simple expression, [ relational operator, simple expression ] ; 

simple expression= [ sign ], term, { term operator, term } ; 

term= factor, { factor operator, factor } ; 

factor= 
"(", expression, ")" | 
logical negation operator, factor | 
value designator | function call | 
value constructor | constant literal ; 

     Ordinal Expressions 
     Infix Expressions and Operations 
     Value Designators 
     Value Constructors 
     Constant Literals 
     Constant Expressions 


═══ 5.7.1. Ordinal Expressions ═══

ordinal expression= expression ; 


═══ 5.7.2. Infix Expressions and Operations ═══

relational operator= 
equals operator | inequality operator | 
less than operator | greater than operator | 
less than or equal operator | subset operator | 
greater than or equal operator | superset operator | 
set membership operator ; 

term operator= 
plus operator | set union operator | 
minus operator | set difference operator | 
logical disjunction operator | string catenate symbol ; 

factor operator= 
multiplication operator | set intersection operator | 
division operator | symmetric set difference operator | 
rem operator | div operator | 
mod operator | logical conjunction operator ; 


═══ 5.7.3. Value Designators ═══

value designator= 
entire value | indexed value | 
selected value | dereferenced value ; 

     Entire Values 
     Indexed Values 
     Selected Values 
     Dereferenced Values 
     Function Calls 


═══ 5.7.3.1. Entire Values ═══

entire value= qualified identifier ; 


═══ 5.7.3.2. Indexed Values ═══

indexed value= array value, "[", index expression, { ",", index expression }, 
"]" ; 

array value= value designator ; 


═══ 5.7.3.3. Selected Values ═══

selected value= record value, ".", field identifier ; 

record value= value designator ; 


═══ 5.7.3.4. Dereferenced Values ═══

dereferenced value= pointer value, dereferencing operator ; 

pointer value= value designator ; 


═══ 5.7.3.5. Function Calls ═══

function call= function designator, actual parameters ; 

function designator= value designator ; 


═══ 5.7.4. Value Constructors ═══

value constructor= array constructor | record constructor | set constructor ; 

     Array Constructors 
     Record Constructors 
     Set Constructors 


═══ 5.7.4.1. Array Constructors ═══

array constructor= array type identifier, array constructed value ; 

array type identifier= type identifier ; 

array constructed value= 
"{", repeated structure component, { ",", repeated structure component }, "}" ; 

repeated structure component= 
structure component, [ "BY", repetition factor ] ; 

repetition factor= constant expression ; 

structure component= 
expression | array constructed value | 
record constructed value | set constructed value ; 


═══ 5.7.4.2. Record Constructors ═══

record constructor= record type identifier, record constructed value ; 

record type identifier= type identifier ; 

record constructed value= 
"{", [ structure component, { ",", structure component } ], "}" ; 


═══ 5.7.4.3. Set Constructors ═══

set constructor= set type identifier, set constructed value ; 

set type identifier= type identifier ; 

set constructed value= "{", [ member, { ",", member } ], "}" ; 

member= interval | singleton ; 

interval= ordinal expression, "..", ordinal expression ; 

singleton= ordinal expression ; 


═══ 5.7.5. Constant Literals ═══

constant literal= whole number literal | real literal | string literal ; 


═══ 5.7.6. Constant Expressions ═══

constant expression= expression ; 


═══ 5.8. Parameter Compatibility and Argument Binding ═══

     Actual Parameters 


═══ 5.8.1. Actual Parameters ═══

actual parameters= "(", [ actual parameter list ], ")" ; 

actual parameter list= actual parameter, { ",", actual parameter } ; 

actual parameter= variable designator | expression | type parameter ; 

     Type Parameters 


═══ 5.8.1.1. Type Parameters ═══

type parameter= type identifier ;